//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2022 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if compiler(>=5.5.2) && canImport(_Concurrency)

import SotoCore

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Greengrass {
    // MARK: Async API Calls

    /// Associates a role with a group. Your Greengrass core will use the role to access AWS cloud services. The role's permissions should allow Greengrass core Lambda functions to perform actions against the cloud.
    public func associateRoleToGroup(_ input: AssociateRoleToGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> AssociateRoleToGroupResponse {
        return try await self.client.execute(operation: "AssociateRoleToGroup", path: "/greengrass/groups/{GroupId}/role", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Associates a role with your account. AWS IoT Greengrass will use the role to access your Lambda functions and AWS IoT resources. This is necessary for deployments to succeed. The role must have at least minimum permissions in the policy ''AWSGreengrassResourceAccessRolePolicy''.
    public func associateServiceRoleToAccount(_ input: AssociateServiceRoleToAccountRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> AssociateServiceRoleToAccountResponse {
        return try await self.client.execute(operation: "AssociateServiceRoleToAccount", path: "/greengrass/servicerole", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a connector definition. You may provide the initial version of the connector definition now or use ''CreateConnectorDefinitionVersion'' at a later time.
    public func createConnectorDefinition(_ input: CreateConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateConnectorDefinitionResponse {
        return try await self.client.execute(operation: "CreateConnectorDefinition", path: "/greengrass/definition/connectors", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a connector definition which has already been defined.
    public func createConnectorDefinitionVersion(_ input: CreateConnectorDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateConnectorDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateConnectorDefinitionVersion", path: "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a core definition. You may provide the initial version of the core definition now or use ''CreateCoreDefinitionVersion'' at a later time. Greengrass groups must each contain exactly one Greengrass core.
    public func createCoreDefinition(_ input: CreateCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateCoreDefinitionResponse {
        return try await self.client.execute(operation: "CreateCoreDefinition", path: "/greengrass/definition/cores", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a core definition that has already been defined. Greengrass groups must each contain exactly one Greengrass core.
    public func createCoreDefinitionVersion(_ input: CreateCoreDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateCoreDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateCoreDefinitionVersion", path: "/greengrass/definition/cores/{CoreDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a deployment. ''CreateDeployment'' requests are idempotent with respect to the ''X-Amzn-Client-Token'' token and the request parameters.
    public func createDeployment(_ input: CreateDeploymentRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateDeploymentResponse {
        return try await self.client.execute(operation: "CreateDeployment", path: "/greengrass/groups/{GroupId}/deployments", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a device definition. You may provide the initial version of the device definition now or use ''CreateDeviceDefinitionVersion'' at a later time.
    public func createDeviceDefinition(_ input: CreateDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateDeviceDefinitionResponse {
        return try await self.client.execute(operation: "CreateDeviceDefinition", path: "/greengrass/definition/devices", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a device definition that has already been defined.
    public func createDeviceDefinitionVersion(_ input: CreateDeviceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateDeviceDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateDeviceDefinitionVersion", path: "/greengrass/definition/devices/{DeviceDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a Lambda function definition which contains a list of Lambda functions and their configurations to be used in a group. You can create an initial version of the definition by providing a list of Lambda functions and their configurations now, or use ''CreateFunctionDefinitionVersion'' later.
    public func createFunctionDefinition(_ input: CreateFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateFunctionDefinitionResponse {
        return try await self.client.execute(operation: "CreateFunctionDefinition", path: "/greengrass/definition/functions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a Lambda function definition that has already been defined.
    public func createFunctionDefinitionVersion(_ input: CreateFunctionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateFunctionDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateFunctionDefinitionVersion", path: "/greengrass/definition/functions/{FunctionDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a group. You may provide the initial version of the group or use ''CreateGroupVersion'' at a later time. Tip: You can use the ''gg_group_setup'' package (https://github.com/awslabs/aws-greengrass-group-setup) as a library or command-line application to create and deploy Greengrass groups.
    public func createGroup(_ input: CreateGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateGroupResponse {
        return try await self.client.execute(operation: "CreateGroup", path: "/greengrass/groups", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a CA for the group. If a CA already exists, it will rotate the existing CA.
    public func createGroupCertificateAuthority(_ input: CreateGroupCertificateAuthorityRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateGroupCertificateAuthorityResponse {
        return try await self.client.execute(operation: "CreateGroupCertificateAuthority", path: "/greengrass/groups/{GroupId}/certificateauthorities", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a group which has already been defined.
    public func createGroupVersion(_ input: CreateGroupVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateGroupVersionResponse {
        return try await self.client.execute(operation: "CreateGroupVersion", path: "/greengrass/groups/{GroupId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a logger definition. You may provide the initial version of the logger definition now or use ''CreateLoggerDefinitionVersion'' at a later time.
    public func createLoggerDefinition(_ input: CreateLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateLoggerDefinitionResponse {
        return try await self.client.execute(operation: "CreateLoggerDefinition", path: "/greengrass/definition/loggers", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a logger definition that has already been defined.
    public func createLoggerDefinitionVersion(_ input: CreateLoggerDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateLoggerDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateLoggerDefinitionVersion", path: "/greengrass/definition/loggers/{LoggerDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a resource definition which contains a list of resources to be used in a group. You can create an initial version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
    public func createResourceDefinition(_ input: CreateResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateResourceDefinitionResponse {
        return try await self.client.execute(operation: "CreateResourceDefinition", path: "/greengrass/definition/resources", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a resource definition that has already been defined.
    public func createResourceDefinitionVersion(_ input: CreateResourceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateResourceDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateResourceDefinitionVersion", path: "/greengrass/definition/resources/{ResourceDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional commands to manage a Greengrass core software update job.
    public func createSoftwareUpdateJob(_ input: CreateSoftwareUpdateJobRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateSoftwareUpdateJobResponse {
        return try await self.client.execute(operation: "CreateSoftwareUpdateJob", path: "/greengrass/updates", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a subscription definition. You may provide the initial version of the subscription definition now or use ''CreateSubscriptionDefinitionVersion'' at a later time.
    public func createSubscriptionDefinition(_ input: CreateSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateSubscriptionDefinitionResponse {
        return try await self.client.execute(operation: "CreateSubscriptionDefinition", path: "/greengrass/definition/subscriptions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a version of a subscription definition which has already been defined.
    public func createSubscriptionDefinitionVersion(_ input: CreateSubscriptionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateSubscriptionDefinitionVersionResponse {
        return try await self.client.execute(operation: "CreateSubscriptionDefinitionVersion", path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a connector definition.
    public func deleteConnectorDefinition(_ input: DeleteConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteConnectorDefinitionResponse {
        return try await self.client.execute(operation: "DeleteConnectorDefinition", path: "/greengrass/definition/connectors/{ConnectorDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a core definition.
    public func deleteCoreDefinition(_ input: DeleteCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteCoreDefinitionResponse {
        return try await self.client.execute(operation: "DeleteCoreDefinition", path: "/greengrass/definition/cores/{CoreDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a device definition.
    public func deleteDeviceDefinition(_ input: DeleteDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteDeviceDefinitionResponse {
        return try await self.client.execute(operation: "DeleteDeviceDefinition", path: "/greengrass/definition/devices/{DeviceDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a Lambda function definition.
    public func deleteFunctionDefinition(_ input: DeleteFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteFunctionDefinitionResponse {
        return try await self.client.execute(operation: "DeleteFunctionDefinition", path: "/greengrass/definition/functions/{FunctionDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a group.
    public func deleteGroup(_ input: DeleteGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteGroupResponse {
        return try await self.client.execute(operation: "DeleteGroup", path: "/greengrass/groups/{GroupId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a logger definition.
    public func deleteLoggerDefinition(_ input: DeleteLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteLoggerDefinitionResponse {
        return try await self.client.execute(operation: "DeleteLoggerDefinition", path: "/greengrass/definition/loggers/{LoggerDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a resource definition.
    public func deleteResourceDefinition(_ input: DeleteResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteResourceDefinitionResponse {
        return try await self.client.execute(operation: "DeleteResourceDefinition", path: "/greengrass/definition/resources/{ResourceDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a subscription definition.
    public func deleteSubscriptionDefinition(_ input: DeleteSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteSubscriptionDefinitionResponse {
        return try await self.client.execute(operation: "DeleteSubscriptionDefinition", path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Disassociates the role from a group.
    public func disassociateRoleFromGroup(_ input: DisassociateRoleFromGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DisassociateRoleFromGroupResponse {
        return try await self.client.execute(operation: "DisassociateRoleFromGroup", path: "/greengrass/groups/{GroupId}/role", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Disassociates the service role from your account. Without a service role, deployments will not work.
    public func disassociateServiceRoleFromAccount(_ input: DisassociateServiceRoleFromAccountRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DisassociateServiceRoleFromAccountResponse {
        return try await self.client.execute(operation: "DisassociateServiceRoleFromAccount", path: "/greengrass/servicerole", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves the role associated with a particular group.
    public func getAssociatedRole(_ input: GetAssociatedRoleRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetAssociatedRoleResponse {
        return try await self.client.execute(operation: "GetAssociatedRole", path: "/greengrass/groups/{GroupId}/role", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Returns the status of a bulk deployment.
    public func getBulkDeploymentStatus(_ input: GetBulkDeploymentStatusRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetBulkDeploymentStatusResponse {
        return try await self.client.execute(operation: "GetBulkDeploymentStatus", path: "/greengrass/bulk/deployments/{BulkDeploymentId}/status", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves the connectivity information for a core.
    public func getConnectivityInfo(_ input: GetConnectivityInfoRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetConnectivityInfoResponse {
        return try await self.client.execute(operation: "GetConnectivityInfo", path: "/greengrass/things/{ThingName}/connectivityInfo", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a connector definition.
    public func getConnectorDefinition(_ input: GetConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetConnectorDefinitionResponse {
        return try await self.client.execute(operation: "GetConnectorDefinition", path: "/greengrass/definition/connectors/{ConnectorDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a connector definition version, including the connectors that the version contains. Connectors are prebuilt modules that interact with local infrastructure, device protocols, AWS, and other cloud services.
    public func getConnectorDefinitionVersion(_ input: GetConnectorDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetConnectorDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetConnectorDefinitionVersion", path: "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a core definition version.
    public func getCoreDefinition(_ input: GetCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetCoreDefinitionResponse {
        return try await self.client.execute(operation: "GetCoreDefinition", path: "/greengrass/definition/cores/{CoreDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a core definition version.
    public func getCoreDefinitionVersion(_ input: GetCoreDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetCoreDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetCoreDefinitionVersion", path: "/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Returns the status of a deployment.
    public func getDeploymentStatus(_ input: GetDeploymentStatusRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetDeploymentStatusResponse {
        return try await self.client.execute(operation: "GetDeploymentStatus", path: "/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a device definition.
    public func getDeviceDefinition(_ input: GetDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetDeviceDefinitionResponse {
        return try await self.client.execute(operation: "GetDeviceDefinition", path: "/greengrass/definition/devices/{DeviceDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a device definition version.
    public func getDeviceDefinitionVersion(_ input: GetDeviceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetDeviceDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetDeviceDefinitionVersion", path: "/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a Lambda function definition, including its creation time and latest version.
    public func getFunctionDefinition(_ input: GetFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetFunctionDefinitionResponse {
        return try await self.client.execute(operation: "GetFunctionDefinition", path: "/greengrass/definition/functions/{FunctionDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a Lambda function definition version, including which Lambda functions are included in the version and their configurations.
    public func getFunctionDefinitionVersion(_ input: GetFunctionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetFunctionDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetFunctionDefinitionVersion", path: "/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a group.
    public func getGroup(_ input: GetGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetGroupResponse {
        return try await self.client.execute(operation: "GetGroup", path: "/greengrass/groups/{GroupId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retreives the CA associated with a group. Returns the public key of the CA.
    public func getGroupCertificateAuthority(_ input: GetGroupCertificateAuthorityRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetGroupCertificateAuthorityResponse {
        return try await self.client.execute(operation: "GetGroupCertificateAuthority", path: "/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves the current configuration for the CA used by the group.
    public func getGroupCertificateConfiguration(_ input: GetGroupCertificateConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetGroupCertificateConfigurationResponse {
        return try await self.client.execute(operation: "GetGroupCertificateConfiguration", path: "/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a group version.
    public func getGroupVersion(_ input: GetGroupVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetGroupVersionResponse {
        return try await self.client.execute(operation: "GetGroupVersion", path: "/greengrass/groups/{GroupId}/versions/{GroupVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a logger definition.
    public func getLoggerDefinition(_ input: GetLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetLoggerDefinitionResponse {
        return try await self.client.execute(operation: "GetLoggerDefinition", path: "/greengrass/definition/loggers/{LoggerDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a logger definition version.
    public func getLoggerDefinitionVersion(_ input: GetLoggerDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetLoggerDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetLoggerDefinitionVersion", path: "/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a resource definition, including its creation time and latest version.
    public func getResourceDefinition(_ input: GetResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetResourceDefinitionResponse {
        return try await self.client.execute(operation: "GetResourceDefinition", path: "/greengrass/definition/resources/{ResourceDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a resource definition version, including which resources are included in the version.
    public func getResourceDefinitionVersion(_ input: GetResourceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetResourceDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetResourceDefinitionVersion", path: "/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves the service role that is attached to your account.
    public func getServiceRoleForAccount(_ input: GetServiceRoleForAccountRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetServiceRoleForAccountResponse {
        return try await self.client.execute(operation: "GetServiceRoleForAccount", path: "/greengrass/servicerole", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a subscription definition.
    public func getSubscriptionDefinition(_ input: GetSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetSubscriptionDefinitionResponse {
        return try await self.client.execute(operation: "GetSubscriptionDefinition", path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves information about a subscription definition version.
    public func getSubscriptionDefinitionVersion(_ input: GetSubscriptionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetSubscriptionDefinitionVersionResponse {
        return try await self.client.execute(operation: "GetSubscriptionDefinitionVersion", path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Get the runtime configuration of a thing.
    public func getThingRuntimeConfiguration(_ input: GetThingRuntimeConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetThingRuntimeConfigurationResponse {
        return try await self.client.execute(operation: "GetThingRuntimeConfiguration", path: "/greengrass/things/{ThingName}/runtimeconfig", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets a paginated list of the deployments that have been started in a bulk deployment operation, and their current deployment status.
    public func listBulkDeploymentDetailedReports(_ input: ListBulkDeploymentDetailedReportsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListBulkDeploymentDetailedReportsResponse {
        return try await self.client.execute(operation: "ListBulkDeploymentDetailedReports", path: "/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Returns a list of bulk deployments.
    public func listBulkDeployments(_ input: ListBulkDeploymentsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListBulkDeploymentsResponse {
        return try await self.client.execute(operation: "ListBulkDeployments", path: "/greengrass/bulk/deployments", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a connector definition, which are containers for connectors. Connectors run on the Greengrass core and contain built-in integration with local infrastructure, device protocols, AWS, and other cloud services.
    public func listConnectorDefinitionVersions(_ input: ListConnectorDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListConnectorDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListConnectorDefinitionVersions", path: "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of connector definitions.
    public func listConnectorDefinitions(_ input: ListConnectorDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListConnectorDefinitionsResponse {
        return try await self.client.execute(operation: "ListConnectorDefinitions", path: "/greengrass/definition/connectors", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a core definition.
    public func listCoreDefinitionVersions(_ input: ListCoreDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListCoreDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListCoreDefinitionVersions", path: "/greengrass/definition/cores/{CoreDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of core definitions.
    public func listCoreDefinitions(_ input: ListCoreDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListCoreDefinitionsResponse {
        return try await self.client.execute(operation: "ListCoreDefinitions", path: "/greengrass/definition/cores", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Returns a history of deployments for the group.
    public func listDeployments(_ input: ListDeploymentsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListDeploymentsResponse {
        return try await self.client.execute(operation: "ListDeployments", path: "/greengrass/groups/{GroupId}/deployments", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a device definition.
    public func listDeviceDefinitionVersions(_ input: ListDeviceDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListDeviceDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListDeviceDefinitionVersions", path: "/greengrass/definition/devices/{DeviceDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of device definitions.
    public func listDeviceDefinitions(_ input: ListDeviceDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListDeviceDefinitionsResponse {
        return try await self.client.execute(operation: "ListDeviceDefinitions", path: "/greengrass/definition/devices", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a Lambda function definition.
    public func listFunctionDefinitionVersions(_ input: ListFunctionDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListFunctionDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListFunctionDefinitionVersions", path: "/greengrass/definition/functions/{FunctionDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of Lambda function definitions.
    public func listFunctionDefinitions(_ input: ListFunctionDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListFunctionDefinitionsResponse {
        return try await self.client.execute(operation: "ListFunctionDefinitions", path: "/greengrass/definition/functions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves the current CAs for a group.
    public func listGroupCertificateAuthorities(_ input: ListGroupCertificateAuthoritiesRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListGroupCertificateAuthoritiesResponse {
        return try await self.client.execute(operation: "ListGroupCertificateAuthorities", path: "/greengrass/groups/{GroupId}/certificateauthorities", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a group.
    public func listGroupVersions(_ input: ListGroupVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListGroupVersionsResponse {
        return try await self.client.execute(operation: "ListGroupVersions", path: "/greengrass/groups/{GroupId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of groups.
    public func listGroups(_ input: ListGroupsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListGroupsResponse {
        return try await self.client.execute(operation: "ListGroups", path: "/greengrass/groups", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a logger definition.
    public func listLoggerDefinitionVersions(_ input: ListLoggerDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListLoggerDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListLoggerDefinitionVersions", path: "/greengrass/definition/loggers/{LoggerDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of logger definitions.
    public func listLoggerDefinitions(_ input: ListLoggerDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListLoggerDefinitionsResponse {
        return try await self.client.execute(operation: "ListLoggerDefinitions", path: "/greengrass/definition/loggers", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a resource definition.
    public func listResourceDefinitionVersions(_ input: ListResourceDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListResourceDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListResourceDefinitionVersions", path: "/greengrass/definition/resources/{ResourceDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of resource definitions.
    public func listResourceDefinitions(_ input: ListResourceDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListResourceDefinitionsResponse {
        return try await self.client.execute(operation: "ListResourceDefinitions", path: "/greengrass/definition/resources", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the versions of a subscription definition.
    public func listSubscriptionDefinitionVersions(_ input: ListSubscriptionDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListSubscriptionDefinitionVersionsResponse {
        return try await self.client.execute(operation: "ListSubscriptionDefinitionVersions", path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of subscription definitions.
    public func listSubscriptionDefinitions(_ input: ListSubscriptionDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListSubscriptionDefinitionsResponse {
        return try await self.client.execute(operation: "ListSubscriptionDefinitions", path: "/greengrass/definition/subscriptions", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Retrieves a list of resource tags for a resource arn.
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListTagsForResourceResponse {
        return try await self.client.execute(operation: "ListTagsForResource", path: "/tags/{ResourceArn}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Resets a group's deployments.
    public func resetDeployments(_ input: ResetDeploymentsRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ResetDeploymentsResponse {
        return try await self.client.execute(operation: "ResetDeployments", path: "/greengrass/groups/{GroupId}/deployments/$reset", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deploys multiple groups in one operation. This action starts the bulk deployment of a specified set of group versions. Each group version deployment will be triggered with an adaptive rate that has a fixed upper limit. We recommend that you include an ''X-Amzn-Client-Token'' token in every ''StartBulkDeployment'' request. These requests are idempotent with respect to the token and the request parameters.
    public func startBulkDeployment(_ input: StartBulkDeploymentRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> StartBulkDeploymentResponse {
        return try await self.client.execute(operation: "StartBulkDeployment", path: "/greengrass/bulk/deployments", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Stops the execution of a bulk deployment. This action returns a status of ''Stopping'' until the deployment is stopped. You cannot start a new bulk deployment while a previous deployment is in the ''Stopping'' state. This action doesn't rollback completed deployments or cancel pending deployments.
    public func stopBulkDeployment(_ input: StopBulkDeploymentRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> StopBulkDeploymentResponse {
        return try await self.client.execute(operation: "StopBulkDeployment", path: "/greengrass/bulk/deployments/{BulkDeploymentId}/$stop", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Adds tags to a Greengrass resource. Valid resources are 'Group', 'ConnectorDefinition', 'CoreDefinition', 'DeviceDefinition', 'FunctionDefinition', 'LoggerDefinition', 'SubscriptionDefinition', 'ResourceDefinition', and 'BulkDeployment'.
    public func tagResource(_ input: TagResourceRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "TagResource", path: "/tags/{ResourceArn}", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Remove resource tags from a Greengrass Resource.
    public func untagResource(_ input: UntagResourceRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "UntagResource", path: "/tags/{ResourceArn}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates the connectivity information for the core. Any devices that belong to the group which has this core will receive this information in order to find the location of the core and connect to it.
    public func updateConnectivityInfo(_ input: UpdateConnectivityInfoRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateConnectivityInfoResponse {
        return try await self.client.execute(operation: "UpdateConnectivityInfo", path: "/greengrass/things/{ThingName}/connectivityInfo", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a connector definition.
    public func updateConnectorDefinition(_ input: UpdateConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateConnectorDefinitionResponse {
        return try await self.client.execute(operation: "UpdateConnectorDefinition", path: "/greengrass/definition/connectors/{ConnectorDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a core definition.
    public func updateCoreDefinition(_ input: UpdateCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateCoreDefinitionResponse {
        return try await self.client.execute(operation: "UpdateCoreDefinition", path: "/greengrass/definition/cores/{CoreDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a device definition.
    public func updateDeviceDefinition(_ input: UpdateDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateDeviceDefinitionResponse {
        return try await self.client.execute(operation: "UpdateDeviceDefinition", path: "/greengrass/definition/devices/{DeviceDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a Lambda function definition.
    public func updateFunctionDefinition(_ input: UpdateFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateFunctionDefinitionResponse {
        return try await self.client.execute(operation: "UpdateFunctionDefinition", path: "/greengrass/definition/functions/{FunctionDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a group.
    public func updateGroup(_ input: UpdateGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateGroupResponse {
        return try await self.client.execute(operation: "UpdateGroup", path: "/greengrass/groups/{GroupId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates the Certificate expiry time for a group.
    public func updateGroupCertificateConfiguration(_ input: UpdateGroupCertificateConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateGroupCertificateConfigurationResponse {
        return try await self.client.execute(operation: "UpdateGroupCertificateConfiguration", path: "/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a logger definition.
    public func updateLoggerDefinition(_ input: UpdateLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateLoggerDefinitionResponse {
        return try await self.client.execute(operation: "UpdateLoggerDefinition", path: "/greengrass/definition/loggers/{LoggerDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a resource definition.
    public func updateResourceDefinition(_ input: UpdateResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateResourceDefinitionResponse {
        return try await self.client.execute(operation: "UpdateResourceDefinition", path: "/greengrass/definition/resources/{ResourceDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a subscription definition.
    public func updateSubscriptionDefinition(_ input: UpdateSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateSubscriptionDefinitionResponse {
        return try await self.client.execute(operation: "UpdateSubscriptionDefinition", path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates the runtime configuration of a thing.
    public func updateThingRuntimeConfiguration(_ input: UpdateThingRuntimeConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateThingRuntimeConfigurationResponse {
        return try await self.client.execute(operation: "UpdateThingRuntimeConfiguration", path: "/greengrass/things/{ThingName}/runtimeconfig", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }
}

#endif // compiler(>=5.5.2) && canImport(_Concurrency)
